// StateValidator.java
package org.zjx.core.state;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.function.Predicate;

/**
 * 线程安全的状态验证器
 *
 * 这个类提供了状态验证功能，包括领域特定规则和全局规则的验证。
 * 所有状态变更都需要通过此验证器检查，确保状态的一致性和有效性。
 */
public class StateValidator {
    // 领域规则映射
    // 键: 状态领域类
    // 值: 该领域的验证规则列表
    private final Map<Class<? extends StateComponent>, List<Predicate<?>>> domainRules = new ConcurrentHashMap<>();

    // 全局规则列表
    private final List<Predicate<StateAccessor>> globalRules = new CopyOnWriteArrayList<>();

    /**
     * 添加领域规则
     *
     * @param <T> 状态领域类型
     * @param domainType 状态领域类
     * @param rule 验证规则
     */
    public <T extends StateComponent> void addDomainRule(Class<T> domainType, Predicate<T> rule) {
        domainRules.computeIfAbsent(domainType, k -> new CopyOnWriteArrayList<>())
                .add(rule);
    }

    /**
     * 添加全局规则
     *
     * @param rule 全局验证规则
     */
    public void addGlobalRule(Predicate<StateAccessor> rule) {
        globalRules.add(rule);
    }

    /**
     * 验证单个组件
     */
    public <T extends StateComponent> boolean validate(T component) {
        if (component == null) {
            return false;
        }

        @SuppressWarnings("unchecked")
        List<Predicate<T>> rules = (List<Predicate<T>>) (List<?>) domainRules.get(component.getClass());

        if (rules == null) {
            return true; // 没有定义规则视为验证通过
        }

        return rules.stream().allMatch(rule -> rule.test(component));
    }

    /**
     * 验证当前状态（实时版本）
     */
    public boolean validate(StateAccessor accessor) {
        // 先检查全局规则
        if (!globalRules.stream().allMatch(rule -> rule.test(accessor))) {
            return false;
        }

        // 检查所有已注册领域组件的规则
        return domainRules.entrySet().parallelStream().allMatch(entry  -> {
                    Class<? extends StateComponent> type = entry.getKey();
                    Optional<? extends StateComponent> component = accessor.getComponent(type);

                    if (component.isEmpty()) {
                        return true; // 组件不存在视为验证通过
                    }

                    @SuppressWarnings("unchecked")
                    List<Predicate<Object>> rules = (List<Predicate<Object>>) (List<?>) entry.getValue();

                    return rules.stream().allMatch(rule -> rule.test(component.get()));
                });
    }


    // 内置规则

    /**
      * 内置全局规则 - 检查组件ID唯一性
     */
    public static final Predicate<StateAccessor> UNIQUE_COMPONENT_IDS = accessor -> {
        Set<String> ids = new HashSet<>();
        // 假设我们有一个方法获取所有StateDomain组件
        return accessor.getAllComponents().stream()
                .filter(Objects::nonNull)
                .allMatch(c -> ids.add(c.getStateType()));
    };

}